package com.njupt.simulation.utils;

public class Antenna465 {

    /**
     * 计算 D/λ 的方法
     * @param Gmax  最大增益
     * @param n  天线效率
     * @return  D/λ
     */
    private static double calculateDOverLambda(double Gmax, double n) {
        return Math.sqrt(Math.pow(10 ,Gmax / 10) / (n * Math.PI * Math.PI));
    }

    /**
     * 计算 G1 的方法
     * @param D_over_lambda  D/λ
     * @return
     */
    public static double calculateG1(double D_over_lambda) {
        if (D_over_lambda > 100) {
            return 32; // 当 D/λ > 100 时，G1 = 32
        } else {
            return -18 + 25 * Math.log10(D_over_lambda); // 当 D/λ ≤ 100 时，G1 = -18 + 25 * log10(D/λ)
        }
    }

    //

    /**
     *  计算 phi_r 的方法
     * @param D_over_lambda D/λ
     * @return   phi_r
     */
    public static double calculatePhiR(double D_over_lambda) {
        if (D_over_lambda > 100) {
            return 1; // 当 D/λ > 100 时，phi_r = 1
        } else {
            return 100 / D_over_lambda; // 当 D/λ ≤ 100 时，phi_r = 100 / (D/λ)
        }
    }

    /**
     * 计算phi_b的方法
     * @return  phi_b
     */
    public static double calculatePhiB() {
        return Math.pow(10, 42.0 / 25); // phi_b = 10^(42/25)
    }

    /**
     * 计算 G 的方法
     * @param phi  偏轴角
     * @param Gmax  波束中心最大增益
     * @param n  天线效率
     * @return
     */
    public static double calculateG(double phi, double Gmax, double n) {
        double G;
        double D_over_lambda = calculateDOverLambda(Gmax, n);

        double phi_m = 20 / D_over_lambda * Math.sqrt(Gmax - calculateG1(D_over_lambda));
        double phi_r = calculatePhiR(D_over_lambda);
        double phi_b = calculatePhiB();

        if (phi >= 0 && phi < phi_m) {
            // 当 0° ≤ φ < phi_m 时，G = Gmax - 2.5x10^(-3) * (D/λ)^2 * φ^2
            G = Gmax - 2.5 * Math.pow(10, -3) * Math.pow(D_over_lambda *phi, 2) ;
        } else if (phi >= phi_m && phi < phi_r) {
            // 当 phi_m ≤ φ < phi_r 时，G = G1
            G = calculateG1(D_over_lambda);
        } else if (phi >= phi_r && phi < phi_b) {
            // 当 phi_r ≤ φ < phi_b 时，G = 32 - 25 * log10(φ)
            G = 32 - 25 * Math.log10(phi);
        } else if (phi >= phi_b && phi <= 180) {
            // 当 phi_b ≤ φ ≤ 180° 时，G = -10
            G = -10;
        } else {
            // 如果 φ 超出了0到180度的范围，抛出一个异常
            throw new IllegalArgumentException("Phi must be between 0 and 180 degrees.");
        }

        return G; // 返回计算得到的 G 值
    }
    public static void main(String[] args) {
        for(double i=0.1;i<90;i+=0.1) {

            double gain = calculateG(i,20, 0.6);
            System.out.println(i);
            System.out.println("增益："+gain);
        }

    }
}
